package com.seeyon.ctp.rest.resources;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.seeyon.apps.lzmzj.kit.*;
import com.seeyon.apps.lzmzj.manager.MatrimonyFunctionManager;
import com.seeyon.ctp.common.AppContext;
import com.seeyon.ctp.common.authenticate.domain.User;
import com.seeyon.ctp.common.config.PerformanceConfig;
import com.seeyon.ctp.common.constants.ApplicationCategoryEnum;
import com.seeyon.ctp.common.exceptions.BusinessException;
import com.seeyon.ctp.common.filemanager.manager.AttachmentManager;
import com.seeyon.ctp.common.filemanager.manager.FileManager;
import com.seeyon.ctp.common.log.CtpLogFactory;
import com.seeyon.ctp.common.po.filemanager.Attachment;
import com.seeyon.ctp.common.po.filemanager.V3XFile;
import com.seeyon.ctp.login.UserUtil;
import com.seeyon.ctp.organization.bo.V3xOrgMember;
import com.seeyon.ctp.organization.manager.OrgManager;
import com.seeyon.ctp.util.EnumUtil;
import com.seeyon.ctp.util.UUIDLong;
import com.seeyon.ctp.util.annotation.RestInterfaceAnnotation;
import com.seeyon.ctp.util.json.JSONUtil;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.*;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Path("jssdk")
@Consumes(MediaType.APPLICATION_JSON)
@Produces({MediaType.APPLICATION_JSON})
public class MatrimonyResources extends BaseResource {

    private static final Log log = CtpLogFactory.getLog(MatrimonyResources.class);

    private static final String userName = AppContext.getSystemProperty("oa.userName");
    private static final String password = AppContext.getSystemProperty("oa.password");

    @Context
    private HttpServletRequest request;

    @Context
    private HttpServletResponse response;

    private AttachmentManager attachmentManager = (AttachmentManager) AppContext.getBean("attachmentManager");
    private FileManager fileManager = (FileManager) AppContext.getBean("fileManager");
    private OrgManager orgManager = (OrgManager) AppContext.getBean("orgManager");
    private MatrimonyFunctionManager matrimonyFunctionManager = (MatrimonyFunctionManager) AppContext.getBean("matrimonyFunctionManager");

    private String localAddr = AppContext.getRawRequest().getLocalAddr();
    private String port = String.valueOf(AppContext.getRawRequest().getLocalPort());
    private String url = "http://" + localAddr + ":" + port;

    /**
     * 处理婚姻预约信息查询请求
     * <p>
     * 该方法用于接收从第三方系统发送的婚姻预约信息查询请求，并返回相应的响应
     * 它首先验证请求的认证信息，然后处理请求参数，检查必要字段的完整性，
     * 最后调用业务逻辑层获取预约信息，并将结果封装后返回
     *
     * @param param 请求参数，包含查询预约信息所需的必要字段
     * @return 返回预约信息查询结果的响应对象
     */
    @POST
    @Path("get/matrimony/appointment/info")
    public Response matrimonyAppointment(Map<String, Object> param) {
        Map<String, Object> dataMap = new HashMap<String, Object>();
        try {
            // 记录请求的日志信息
            log.info("第三方系统调用自定义发起表单协同接口推送数据json报文:" + JSON.toJSONString(param));

            // 获取当前HTTP请求
            HttpServletRequest request = AppContext.getRawRequest();

            // 执行认证，检查请求是否经过验证
            String authenticationStr = AuthenticationKit.isAuthenticated(request, userName, password, "data");
            if (!"".equals(authenticationStr)) {
                return ok(authenticationStr);
            }

            // 将请求参数转换为JSONObject
            JSONObject jsonObject = new JSONObject(param);

            // 初始化并检查区域字段
            String region = "";
            if (jsonObject.containsKey("region")) {
                region = StrKit.str(jsonObject.get("region"));
            }
            if ("".equals(region)) {
                String result = MessageKit.msg("E", "data", "", "region 区域[" + region + "]不能为空值!");
                return ok(result);
            }

            // 初始化并检查预约类型字段
            String type = "";
            if (jsonObject.containsKey("type")) {
                type = StrKit.str(jsonObject.get("type"));
            }
            if ("".equals(type)) {
                String result = MessageKit.msg("E", "data", "", "type 预约类型[" + type + "]不能为空值!");
                return ok(result);
            }

            // 初始化并检查预约年份字段
            String year = "";
            if (jsonObject.containsKey("year")) {
                year = StrKit.str(jsonObject.get("year"));
            }
            if ("".equals(year)) {
                String result = MessageKit.msg("E", "data", "", "year 预约年份[" + year + "]不能为空值!");
                return ok(result);
            }

            // 初始化并检查预约月份字段
            String month = "";
            if (jsonObject.containsKey("month")) {
                month = StrKit.str(jsonObject.get("month"));
            }
            if ("".equals(month)) {
                String result = MessageKit.msg("E", "data", "", "month 预约月份[" + month + "]不能为空值!");
                return ok(result);
            }

            // 调用业务逻辑层获取预约信息列表
            dataMap = matrimonyFunctionManager.getMatrimonyAppointmentDateList(param);

            // 构造并返回成功响应
            String result = MessageKit.msg("S", "data", dataMap, "");
            return ok(result);
        } catch (Exception e) {
            // 记录异常日志信息
            log.error("婚姻预约接口异常信息:", e);

            // 构造并返回错误响应
            String result = MessageKit.msg("E", "data", dataMap, e.getMessage());
            return ok(result);
        }
    }

    /**
     * 查询结婚(离婚)登记审批状态接口
     * 该方法用于接收第三方系统查询结婚登记审批状态的请求，并返回相应的响应
     *
     * @param param 包含查询参数的Map对象
     * @return 返回一个Response对象，包含查询结果或错误信息
     */
    @POST
    @Path("query/marriage/registration/approval/status")
    public Response queryMarriageregistrationApprovalStatus(Map<String, Object> param) {
        try {
            // 记录日志：第三方系统推送的数据json报文
            log.info("第三方系统调用查询结婚登记审批状态接口推送数据json报文:" + JSON.toJSONString(param));

            // 获取当前请求对象
            HttpServletRequest request = AppContext.getRawRequest();

            // 验证请求的身份认证信息
            String authenticationStr = AuthenticationKit.isAuthenticated(request, userName, password, "data");

            // 如果认证信息不为空，则返回认证信息表示认证未通过
            if (!"".equals(authenticationStr)) {
                return ok(authenticationStr);
            }

            // 将查询参数转换为JSONObject对象
            JSONObject jsonObject = new JSONObject(param);
            if (jsonObject.containsKey("type")) {
                String type = StrKit.str(jsonObject.get("type"));
                if ("".equals(type)) {
                    String result = MessageKit.msg("E", "data", "", "type 类型[" + type + "]不能为空值!");
                    return ok(result);
                }
            } else {
                // 如果查询参数中不包含预约编号，则返回错误信息
                String result = MessageKit.msg("E", "data", "", "type 类型不能为空!");
                return ok(result);
            }

            // 检查查询参数中是否包含预约编号
            if (jsonObject.containsKey("reservationNumber")) {
                // 获取预约编号
                String reservationNumber = StrKit.str(jsonObject.get("reservationNumber"));

                // 如果预约编号为空，则返回错误信息
                if ("".equals(reservationNumber)) {
                    String result = MessageKit.msg("E", "data", "", "reservationNumber 预约编号[" + reservationNumber + "]不能为空值!");
                    return ok(result);
                }

                // 调用业务管理器获取结婚登记审批状态
                Object result = matrimonyFunctionManager.getMarriageRegistrationApprovalStatus(param, url);
                return ok(result);
            } else {
                // 如果查询参数中不包含预约编号，则返回错误信息
                String result = MessageKit.msg("E", "data", "", "reservationNumber 预约编号不能为空!");
                return ok(result);
            }
        } catch (Exception e) {
            // 记录异常日志：查询结婚登记审批状态接口异常信息
            log.error("查询结婚登记审批状态接口异常信息:", e);

            // 返回异常信息的响应
            return ok(MessageKit.msg("E", "data", "", e.getMessage()));
        }
    }

    /**
     * 查询婚前辅导预约人数接口
     * 该接口用于查询特定条件下的婚前辅导预约人数，条件包括年份、月份和地区
     *
     * @param param 包含查询条件的参数映射，可能包含年份(year)、月份(month)和地区(region)
     * @return 返回查询结果或错误信息的响应对象
     */
    @POST
    @Path("query/premarital/counseling/appointment/number")
    public Response queryPremaritalCounselingAppointmentNumber(Map<String, Object> param) {
        try {
            // 记录接口调用的日志信息
            log.info("第三方系统调用查询婚前辅导预约人数接口推送数据json报文:" + JSON.toJSONString(param));

            // 获取当前请求对象
            HttpServletRequest request = AppContext.getRawRequest();

            // 执行身份验证
            String authenticationStr = AuthenticationKit.isAuthenticated(request, userName, password, "data");
            if (!"".equals(authenticationStr)) {
                return ok(authenticationStr);
            }

            // 将参数映射转换为JSONObject
            JSONObject jsonObject = new JSONObject(param);

            // 验证年份参数
            if (jsonObject.containsKey("year")) {
                String year = StrKit.str(jsonObject.get("year"));
                if ("".equals(year)) {
                    String result = MessageKit.msg("E", "data", "", "year 年[" + year + "]不能为空值!");
                    return ok(result);
                }
            } else {
                String result = MessageKit.msg("E", "data", "", "year 年不能为空!");
                return ok(result);
            }

            // 验证月份参数
            if (jsonObject.containsKey("month")) {
                String month = StrKit.str(jsonObject.get("month"));
                if ("".equals(month)) {
                    String result = MessageKit.msg("E", "data", "", "month 月[" + month + "]不能为空值!");
                    return ok(result);
                }
            } else {
                String result = MessageKit.msg("E", "data", "", "month 月不能为空!");
                return ok(result);
            }

            // 验证地区参数
            if (jsonObject.containsKey("region")) {
                String region = StrKit.str(jsonObject.get("region"));
                if ("".equals(region)) {
                    String result = MessageKit.msg("E", "data", "", "region 地区[" + region + "]不能为空值!");
                    return ok(result);
                }
            } else {
                String result = MessageKit.msg("E", "data", "", "region 地区不能为空!");
                return ok(result);
            }

            // 调用业务逻辑方法获取预约人数
            Object result = matrimonyFunctionManager.getPremaritalCounselingAppointmentNumber(param);
            return ok(result);
        } catch (Exception e) {
            // 记录异常日志信息
            log.error("查询结婚登记审批状态接口异常信息:", e);
            // 返回异常信息
            return ok(MessageKit.msg("E", "data", "", e.getMessage()));
        }
    }

    /**
     * 查询文明婚俗新风数据接口
     * 该方法用于响应外部系统对文明婚俗新风数据的查询请求
     *
     * @param param 包含查询参数的Map对象
     * @return 返回包含查询结果的Response对象
     */
    @POST
    @Path("query/civilization/marriageCustom/newTrend/datas")
    public Response queryCivilizationMarriageCustomNewTrend(Map<String, Object> param) {
        // 记录请求参数信息
        log.info("第三方系统调用查询文明婚俗新风接口推送数据json报文:" + JSON.toJSONString(param));
        try {
            // 获取当前请求对象
            HttpServletRequest request = AppContext.getRawRequest();
            // 执行身份验证
            String authenticationStr = AuthenticationKit.isAuthenticated(request, userName, password, "data");
            // 如果身份验证通过
            if (!"".equals(authenticationStr)) {
                // 返回认证信息
                return ok(authenticationStr);
            }
            Object result = matrimonyFunctionManager.queryCivilizationMarriageCustomNewTrend(param, url);
            // 返回查询结果
            return ok(result);
        } catch (Exception e) {
            // 记录异常日志信息
            log.error("查询文明婚俗新风接口异常信息:", e);
            // 返回异常信息
            return ok(MessageKit.msg("E", "data", "", e.getMessage()));
        }
    }

    /**
     * 通过POST方法提供查询活动发布数据的接口
     *
     * @param param 包含查询参数的映射表，预期包含活动相关的信息
     * @return Response 对请求的响应，包含查询结果或错误信息
     */
    @POST
    @Path("query/event/release/datas")
    public Response queryEventRelease(Map<String, Object> param) {
        // 记录第三方系统调用接口时发送的请求参数
        log.info("第三方系统调用查询活动发布接口推送数据json报文:" + JSON.toJSONString(param));
        try {
            // 获取当前HTTP请求
            HttpServletRequest request = AppContext.getRawRequest();
            // 执行身份验证，确保只有经过认证的用户才能访问数据
            String authenticationStr = AuthenticationKit.isAuthenticated(request, userName, password, "data");
            // 如果身份验证返回的字符串不为空，则返回认证信息作为响应
            if (!"".equals(authenticationStr)) {
                return ok(authenticationStr);
            }
            // 调用业务逻辑方法查询活动发布信息
            Object result = matrimonyFunctionManager.queryEventRelease(param, url);
            // 返回查询结果
            return ok(result);
        } catch (Exception e) {
            // 记录查询活动发布接口时发生的异常
            log.error("查询活动发布接口异常信息:", e);
            // 返回查询异常信息
            return ok(MessageKit.msg("E", "data", "", e.getMessage()));
        }
    }

    /**
     * 通过POST方法查询政策档案数据
     *
     * @param param 包含查询参数的Map对象
     * @return 返回查询政策档案的结果
     */
    @POST
    @Path("query/policy/archives/datas")
    public Response queryPolicyArchives(Map<String, Object> param) {
        // 记录第三方系统调用接口时推送的数据JSON报文
        log.info("第三方系统调用查询政策档案接口推送数据json报文:" + JSON.toJSONString(param));
        try {
            // 获取当前HTTP请求
            HttpServletRequest request = AppContext.getRawRequest();
            // 执行身份验证，确保请求经过合法认证
            String authenticationStr = AuthenticationKit.isAuthenticated(request, userName, password, "data");
            // 如果身份验证未通过，返回认证错误信息
            if (!"".equals(authenticationStr)) {
                return ok(authenticationStr);
            }
            // 调用业务逻辑层方法查询政策档案数据
            Object result = matrimonyFunctionManager.queryPolicyArchives(param);
            // 返回查询结果
            return ok(result);
        } catch (Exception e) {
            // 记录查询政策档案接口的异常信息
            log.error("查询政策档案接口异常信息:", e);
            // 返回异常情况下的提示信息
            return ok(MessageKit.msg("E", "data", "", e.getMessage()));
        }
    }

    /**
     * 查询其他须知接口
     *
     * @param param 参数地图，包含查询其他须知所需的参数
     * @return 返回查询结果或其他相关消息的响应
     */
    @POST
    @Path("query/other/notice/datas")
    public Response queryOtherNotice(Map<String, Object> param) {
        // 记录日志，第三方系统调用查询其他须知接口时发送的JSON数据
        log.info("第三方系统调用查询其他须知接口推送数据json报文:" + JSON.toJSONString(param));
        try {
            // 获取当前HTTP请求
            HttpServletRequest request = AppContext.getRawRequest();
            // 验证请求的身份
            String authenticationStr = AuthenticationKit.isAuthenticated(request, userName, password, "data");
            // 如果身份验证不通过，返回认证信息
            if (!"".equals(authenticationStr)) {
                return ok(authenticationStr);
            }
            // 将参数地图转换为JSONObject
            JSONObject jsonObject = new JSONObject(param);
            // 检查参数中是否包含"type"
            if (jsonObject.containsKey("type")) {
                // 获取"type"的值
                String type = StrKit.str(jsonObject.get("type"));
                // 如果"type"的值为空，返回错误消息
                if ("".equals(type)) {
                    String result = MessageKit.msg("E", "data", "", "type 类型[" + type + "]不能为空值!");
                    return ok(result);
                }
            } else {
                // 如果参数中不包含"type"，返回错误消息
                String result = MessageKit.msg("E", "data", "", "type 类型不能为空!");
                return ok(result);
            }
            // 调用服务管理器的方法查询其他须知
            Object result = matrimonyFunctionManager.queryOtherNotice(param, url);
            // 返回查询结果
            return ok(result);
        } catch (Exception e) {
            // 记录异常日志
            log.error("查询其他设置接口异常信息:", e);
            // 返回异常消息
            return ok(MessageKit.msg("E", "data", "", e.getMessage()));
        }
    }

    /**
     * 根据查询参数返回门户跳转地址
     * 此方法用于处理第三方系统请求的门户跳转地址，根据提供的类型（type）和电话号码（phone）参数，
     * 确定合适的门户跳转地址并实现登录重定向
     *
     * @param param 包含查询参数的映射，包括type和phone
     * @return Response 对于非法的参数或重定向失败的情况，返回错误信息；否则，实现登录重定向
     */
    @GET
    @Path("query/portal/jump/address")
    public Response queryPortalJumpAddress(Map<String, Object> param) {
        // 记录请求日志，包括参数信息
        log.info("第三方系统调用查询门户跳转地址接口推送数据json报文:" + JSON.toJSONString(param));
        try {
            // 获取请求参数type，用于确定跳转类型
            String type = request.getParameter("type");
            if ("".equals(type)) {
                // type参数为空，返回错误信息
                String result = MessageKit.msg("E", "", "", "type 类型[" + type + "]不能为空值!");
                return ok(result);
            }
            // 获取请求参数phone，用于查询登录名
            String phone = request.getParameter("phone");
            if ("".equals(phone)) {
                // phone参数为空，返回错误信息
                String result = MessageKit.msg("E", "", "", "phone 电话[" + phone + "]不能为空值!");
                return ok(result);
            }
            String loginName = "";
            // 根据手机号查询对应的登录名
            if (!"".equals(phone)) {
                List<V3xOrgMember> orgMemberList = orgManager.getMemberListWithOuterByMobile(phone, null);
                if (!orgMemberList.isEmpty()) {
                    loginName = orgMemberList.get(0).getLoginName();
                }
            } else {
                // 手机号未维护，返回错误信息
                String result = MessageKit.msg("E", "", "", "phone 手机号[" + phone + "]未维护!");
                return ok(result);
            }

            // 硬编码的OA系统URL，后续可能通过配置获取
//        String oa_url = AppContext.getSystemProperty("oa.url");
            String oa_url = "http://10.46.19.188:40407";
            String jumpAddress = "";
            // 根据类型选择跳转地址
            if ("H".equals(type)) {
                /*婚姻*/
                jumpAddress = "/seeyon/cap4/bizportal.do?method=viewBizPortalSpace&spaceId=-1119100421985779437";
            } else if ("B".equals(type)) {
                /*儿保*/
                jumpAddress = "/seeyon/cap4/bizportal.do?method=viewBizPortalSpace&spaceId=1396751042567423163";
            } else if ("X".equals(type)) {
                /*项目管理*/
                jumpAddress = "/seeyon/cap4/bizportal.do?method=viewBizPortalSpace&spaceId=8949600933150147858";
            } else if ("F".equals(type)) {
                /*福彩*/
                jumpAddress = "/seeyon/cap4/bizportal.do?method=viewBizPortalSpace&spaceId=6202708762859946927";
            } else if ("C".equals(type)) {
                /*慈善*/
                jumpAddress = "/seeyon/cap4/bizportal.do?method=viewBizPortalSpace&spaceId=3252216267368320955";
            }

            // 构造并执行登录重定向
            if (!"".equals(loginName)) {
                long longUUID = UUIDLong.longUUID();
                String loginName_new = URLEncoder.encode(longUUID + "##" + loginName);
                String url_new = "/seeyon/login/sso?from=dzddsso&ticketInfo=" + loginName_new + "&UserAgentFrom=pc&tourl=" + URLEncoder.encode(jumpAddress);
                System.out.println("url_new:" + url_new);
                log.info("门户跳转url地址:" + url_new);
                response.sendRedirect(url_new);
            } else {
                // 手机号未匹配到账号，返回错误信息
                String result = MessageKit.msg("E", "", "", "手机号[" + phone + "]在系统中未匹配到对应的账号!");
                return ok(result);
            }
        } catch (Exception e) {
            // 处理异常情况，记录日志并返回错误信息
            log.error("门户跳转异常信息:", e);
            String result = MessageKit.msg("E", "", "", "门户跳转失败:" + e.getMessage());
            return ok(result);
        }
        return null;
    }

    /**
     * 上传附件接口
     * 该方法处理附件上传请求，包括验证手机号、处理文件类型和大小限制，
     * 以及最终将文件存储到系统中
     *
     * @return Response 上传结果响应
     */
    @POST
    @Consumes(MediaType.MULTIPART_FORM_DATA)
    @RestInterfaceAnnotation
    @Path("attachment/upload")
    public Response upload() {
        // 开始上传流程
        try {
            // 获取上传时的参数：允许的文件类型、应用分类、手机号
            String extensions = request.getParameter("extensions");
            String applicationCategory = request.getParameter("applicationCategory");
            String phone = request.getHeader("phone");

            // 验证手机号非空
            if ("".equals(phone)) {
                return ok(MessageKit.msg("E", "fileUrl", "", "phone 手机号不能为空!"));
            }

            // 根据手机号查找系统中的成员信息
            List<V3xOrgMember> orgMemberList = orgManager.getMemberListWithOuterByMobile(phone, null);
            if (orgMemberList.isEmpty()) {
                // 如果未找到对应成员，返回错误信息
                String result = MessageKit.msg("E", "fileUrl", "", "phone 根据手机号[" + phone + "]在系统中未找到对应账号或手机号维护有误!");
                return ok(result);
            }

            // 获取用户信息并设置当前用户
            V3xOrgMember v3xOrgMember = (V3xOrgMember) orgMemberList.get(0);
            User user_new = UserUtil.build(v3xOrgMember, "", null);
            if (user_new != null) {
                UserUtil.setCurrentUser(user_new);
            }

            // 获取上传文件类型、是否首次保存、最大文件大小、应用分类等参数
            String typeStr = request.getParameter("type");
            String firstSave = request.getParameter("firstSave") == null ? "" : request.getParameter("firstSave");
            String maxSizeStr = request.getParameter("maxSize");
            String ucFlag = request.getParameter("ucFlag");
            String reference = request.getParameter("reference");

            // 设置上传文件的类型，默认为文件类型
            com.seeyon.ctp.common.filemanager.Constants.ATTACHMENT_TYPE type = null;
            if (StringUtils.isNotBlank(typeStr)) {
                type = EnumUtil.getEnumByOrdinal(com.seeyon.ctp.common.filemanager.Constants.ATTACHMENT_TYPE.class,
                        Integer.valueOf(typeStr));
            } else {
                type = com.seeyon.ctp.common.filemanager.Constants.ATTACHMENT_TYPE.FILE;
            }

            // 确保firstSave参数的值
            if (StringUtils.isBlank(firstSave)) {
                firstSave = "false";
            }

            // 根据应用分类参数设置上传文件的应用分类，默认为全局
            ApplicationCategoryEnum category = null;
            if (StringUtils.isNotBlank(applicationCategory)) {
                category = ApplicationCategoryEnum.valueOf(Integer.valueOf(applicationCategory));
            } else {
                category = ApplicationCategoryEnum.global;
                log.warn("上传文件：v3x:fileUpload没有设定applicationCategory属性，将设置为‘全局’。");
            }

            // 根据参数设置上传文件的最大大小，默认为系统配置的值
            long maxSize = 0L;
            if ("yes".equals(ucFlag)) {
                maxSize = Long.parseLong(PerformanceConfig.getInstance().getConfig("zx.set.file.maxSize")) * 1024 * 1024;
            } else {
                maxSize = Long.parseLong(PerformanceConfig.getInstance().getConfig("fileUpload.maxSize")) * 1024 * 1024;
            }
            if (StringUtils.isNotBlank(maxSizeStr)) {
                maxSize = Long.valueOf(maxSizeStr);
            }

            // 处理上传文件
            Map<String, V3XFile> v3xFiles = null;
            CommonsMultipartResolver resolver = (CommonsMultipartResolver) AppContext.getBean("multipartResolver");
            HttpServletRequest req = resolver.resolveMultipart(request);
            v3xFiles = fileManager.uploadFiles(req, extensions, maxSize);

            // 如果文件上传成功，处理并保存文件信息
            if (v3xFiles != null) {
                List<String> keys = new ArrayList<String>(v3xFiles.keySet());
                List<Attachment> atts = new ArrayList<Attachment>();
                for (String key : keys) {
                    V3XFile file = v3xFiles.get(key);
                    file.setType(type.ordinal());
                    Attachment att = new Attachment(file, category, type);
                    if (("yes".equals(ucFlag)) && (StringUtils.isNotBlank(reference))) {
                        try {
                            Long referenceLong = Long.valueOf(reference);
                            att.setSubReference(Long.valueOf(type.ordinal()));//关联保存致信文件的二级关联用于后面的查询
                            att.setReference(referenceLong);
                        } catch (Exception e) {
                            log.error("致信端传入的reference不符合要求", e);
                        }
                    }
                    atts.add(att);
                    fileManager.save(file);
                }

                // 如果是首次保存，创建附件记录
                if ("true".equalsIgnoreCase(firstSave)) {
                    attachmentManager.create(atts);
                }

                // 返回上传成功的信息
                Map<String, Object> map = new HashMap<String, Object>();
                map.put("n_a_s", 1);
                map.put("atts", atts);
                String fileUrl = StrKit.getFileUrl(JSONUtil.toJSONString4Ajax(map));
                return ok(MessageKit.msg("S", "fileUrl", fileUrl, "附件上传成功"));
            }

            // 如果上传过程中出现异常，返回空响应
            return ok(null);
        } catch (BusinessException e) {
            log.error("", e);
            return ok(MessageKit.msg("E", "fileUrl", "", e.getMessage()));
        } catch (Exception e) {
            log.error("", e);
            return ok(MessageKit.msg("E", "fileUrl", "", e.getMessage()));
        }
    }


}